home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2001 September / PC-WELT 9-2001.ISO / software / hw / brennen / flask_src.exe / Video / getblk.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-06  |  12.5 KB  |  573 lines
  1. /* getblk.c, DCT block decoding                                             */
  2.  
  3. /* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
  4.  
  5. /*
  6.  * Disclaimer of Warranty
  7.  *
  8.  * These software programs are available to the user without any license fee or
  9.  * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
  10.  * any and all warranties, whether express, implied, or statuary, including any
  11.  * implied warranties or merchantability or of fitness for a particular
  12.  * purpose.  In no event shall the copyright-holder be liable for any
  13.  * incidental, punitive, or consequential damages of any kind whatsoever
  14.  * arising from the use of these programs.
  15.  *
  16.  * This disclaimer of warranty extends to the user of these programs and user's
  17.  * customers, employees, agents, transferees, successors, and assigns.
  18.  *
  19.  * The MPEG Software Simulation Group does not represent or warrant that the
  20.  * programs furnished hereunder are free of infringement of any third-party
  21.  * patents.
  22.  *
  23.  * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
  24.  * are subject to royalty fees to patent holders.  Many of these patents are
  25.  * general enough such that they are unavoidable regardless of implementation
  26.  * design.
  27.  *
  28.  */
  29.  
  30. #include <stdio.h>
  31.  
  32. #include "config.h"
  33. #include "global.h"
  34.  
  35. char szTemp[256];
  36.  
  37. /* defined in getvlc.h */
  38. typedef struct {
  39.   char run, level, len;
  40. } DCTtab;
  41.  
  42. extern DCTtab DCTtabfirst[],DCTtabnext[],DCTtab0[],DCTtab1[];
  43. extern DCTtab DCTtab2[],DCTtab3[],DCTtab4[],DCTtab5[],DCTtab6[];
  44. extern DCTtab DCTtab0a[],DCTtab1a[];
  45.  
  46.  
  47. /* decode one intra coded MPEG-1 block */
  48.  
  49. void Decode_MPEG1_Intra_Block(comp,dc_dct_pred)
  50. int comp;
  51. int dc_dct_pred[];
  52. {
  53.   int val, i, j, sign;
  54.   unsigned int code;
  55.   DCTtab *tab;
  56.   short *bp;
  57.  
  58.   bp = ld->block[comp];
  59.  
  60.   /* ISO/IEC 11172-2 section 2.4.3.7: Block layer. */
  61.   /* decode DC coefficients */
  62.   if (comp<4)
  63.     bp[0] = (dc_dct_pred[0]+=Get_Luma_DC_dct_diff()) << 3;
  64.   else if (comp==4)
  65.     bp[0] = (dc_dct_pred[1]+=Get_Chroma_DC_dct_diff()) << 3;
  66.   else
  67.     bp[0] = (dc_dct_pred[2]+=Get_Chroma_DC_dct_diff()) << 3;
  68.  
  69.   if (Fault_Flag) return;
  70.  
  71.   /* D-pictures do not contain AC coefficients */
  72.   if(picture_coding_type == D_TYPE)
  73.     return;
  74.  
  75.   /* decode AC coefficients */
  76.   for (i=1; ; i++)
  77.   {
  78.     code = Show_Bits(16);
  79.     if (code>=16384)
  80.       tab = &DCTtabnext[(code>>12)-4];
  81.     else if (code>=1024)
  82.       tab = &DCTtab0[(code>>8)-4];
  83.     else if (code>=512)
  84.       tab = &DCTtab1[(code>>6)-8];
  85.     else if (code>=256)
  86.       tab = &DCTtab2[(code>>4)-16];
  87.     else if (code>=128)
  88.       tab = &DCTtab3[(code>>3)-16];
  89.     else if (code>=64)
  90.       tab = &DCTtab4[(code>>2)-16];
  91.     else if (code>=32)
  92.       tab = &DCTtab5[(code>>1)-16];
  93.     else if (code>=16)
  94.       tab = &DCTtab6[code-16];
  95.     else
  96.     {
  97.       if (!Quiet_Flag)
  98.         printf("invalid Huffman code in Decode_MPEG1_Intra_Block()\n");
  99.       Fault_Flag = 1;
  100.       return;
  101.     }
  102.  
  103.     Flush_Buffer(tab->len);
  104.  
  105.     if (tab->run==64) /* end_of_block */
  106.       return;
  107.  
  108.     if (tab->run==65) /* escape */
  109.     {
  110.       i+= Get_Bits(6);
  111.  
  112.       val = Get_Bits(8);
  113.       if (val==0)
  114.         val = Get_Bits(8);
  115.       else if (val==128)
  116.         val = Get_Bits(8) - 256;
  117.       else if (val>128)
  118.         val -= 256;
  119.  
  120.       if((sign = (val<0)))
  121.         val = -val;
  122.     }
  123.     else
  124.     {
  125.       i+= tab->run;
  126.       val = tab->level;
  127.       sign = Get_Bits(1);
  128.     }
  129.  
  130.     if (i>=64)
  131.     {
  132.       if (!Quiet_Flag)
  133.         fprintf(stderr,"DCT coeff index (i) out of bounds (intra)\n");
  134.       Fault_Flag = 1;
  135.       return;
  136.     }
  137.  
  138.     j = scan[ZIG_ZAG][i];
  139.     val = (val*ld->quantizer_scale*ld->intra_quantizer_matrix[j]) >> 3;
  140.  
  141.     /* mismatch control ('oddification') */
  142.     if (val!=0) /* should always be true, but it's not guaranteed */
  143.       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
  144.  
  145.     /* saturation */
  146.     if (!sign)
  147.       bp[j] = (val>2047) ?  2047 :  val; /* positive */
  148.     else
  149.       bp[j] = (val>2048) ? -2048 : -val; /* negative */
  150.   }
  151. }
  152.  
  153.  
  154. /* decode one non-intra coded MPEG-1 block */
  155.  
  156. void Decode_MPEG1_Non_Intra_Block(comp)
  157. int comp;
  158. {
  159.   int val, i, j, sign;
  160.   unsigned int code;
  161.   DCTtab *tab;
  162.   short *bp;
  163.  
  164.   bp = ld->block[comp];
  165.  
  166.   /* decode AC coefficients */
  167.   for (i=0; ; i++)
  168.   {
  169.     code = Show_Bits(16);
  170.     if (code>=16384)
  171.     {
  172.       if (i==0)
  173.         tab = &DCTtabfirst[(code>>12)-4];
  174.       else
  175.         tab = &DCTtabnext[(code>>12)-4];
  176.     }
  177.     else if (code>=1024)
  178.       tab = &DCTtab0[(code>>8)-4];
  179.     else if (code>=512)
  180.       tab = &DCTtab1[(code>>6)-8];
  181.     else if (code>=256)
  182.       tab = &DCTtab2[(code>>4)-16];
  183.     else if (code>=128)
  184.       tab = &DCTtab3[(code>>3)-16];
  185.     else if (code>=64)
  186.       tab = &DCTtab4[(code>>2)-16];
  187.     else if (code>=32)
  188.       tab = &DCTtab5[(code>>1)-16];
  189.     else if (code>=16)
  190.       tab = &DCTtab6[code-16];
  191.     else
  192.     {
  193.       if (!Quiet_Flag)
  194.         printf("invalid Huffman code in Decode_MPEG1_Non_Intra_Block()\n");
  195.       Fault_Flag = 1;
  196.       return;
  197.     }
  198.  
  199.     Flush_Buffer(tab->len);
  200.  
  201.     if (tab->run==64) /* end_of_block */
  202.       return;
  203.  
  204.     if (tab->run==65) /* escape */
  205.     {
  206.       i+= Get_Bits(6);
  207.  
  208.       val = Get_Bits(8);
  209.       if (val==0)
  210.         val = Get_Bits(8);
  211.       else if (val==128)
  212.         val = Get_Bits(8) - 256;
  213.       else if (val>128)
  214.         val -= 256;
  215.  
  216.       if((sign = (val<0)))
  217.         val = -val;
  218.     }
  219.     else
  220.     {
  221.       i+= tab->run;
  222.       val = tab->level;
  223.       sign = Get_Bits(1);
  224.     }
  225.  
  226.     if (i>=64)
  227.     {
  228.       if (!Quiet_Flag)
  229.         fprintf(stderr,"DCT coeff index (i) out of bounds (inter)\n");
  230.       Fault_Flag = 1;
  231.       return;
  232.     }
  233.  
  234.     j = scan[ZIG_ZAG][i];
  235.     val = (((val<<1)+1)*ld->quantizer_scale*ld->non_intra_quantizer_matrix[j]) >> 4;
  236.  
  237.     /* mismatch control ('oddification') */
  238.     if (val!=0) /* should always be true, but it's not guaranteed */
  239.       val = (val-1) | 1; /* equivalent to: if ((val&1)==0) val = val - 1; */
  240.  
  241.     /* saturation */
  242.     if (!sign)
  243.       bp[j] = (val>2047) ?  2047 :  val; /* positive */
  244.     else
  245.       bp[j] = (val>2048) ? -2048 : -val; /* negative */
  246.   }
  247. }
  248.  
  249.  
  250. /* decode one intra coded MPEG-2 block */
  251.  
  252. void Decode_MPEG2_Intra_Block(comp,dc_dct_pred)
  253. int comp;
  254. int dc_dct_pred[];
  255. {
  256.   int val, i, j, sign, nc, cc, run;
  257.   unsigned int code;
  258.   DCTtab *tab;
  259.   short *bp;
  260.   int *qmat;
  261.   struct layer_data *ld1;
  262.  
  263.   /* with data partitioning, data always goes to base layer */
  264.   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
  265.   bp = ld1->block[comp];
  266.  
  267.   if (base.scalable_mode==SC_DP)
  268.     if (base.priority_breakpoint<64)
  269.       ld = &enhan;
  270.     else
  271.       ld = &base;
  272.  
  273.   cc = (comp<4) ? 0 : (comp&1)+1;
  274.  
  275.   qmat = (comp<4 || chroma_format==CHROMA420)
  276.          ? ld1->intra_quantizer_matrix
  277.          : ld1->chroma_intra_quantizer_matrix;
  278.  
  279.   /* ISO/IEC 13818-2 section 7.2.1: decode DC coefficients */
  280.   if (cc==0)
  281.     val = (dc_dct_pred[0]+= Get_Luma_DC_dct_diff());
  282.   else if (cc==1)
  283.     val = (dc_dct_pred[1]+= Get_Chroma_DC_dct_diff());
  284.   else
  285.     val = (dc_dct_pred[2]+= Get_Chroma_DC_dct_diff());
  286.  
  287.   if (Fault_Flag) return;
  288.  
  289.   bp[0] = val << (3-intra_dc_precision);
  290.  
  291.   nc=0;
  292.  
  293. #ifdef TRACE
  294.   if (Trace_Flag)
  295.     sprintf(szTemp,"DCT(%d)i:",comp);
  296.   //ShowInConsole( szTemp );
  297. #endif /* TRACE */
  298.  
  299.   /* decode AC coefficients */
  300.   for (i=1; ; i++)
  301.   {
  302.     code = Show_Bits(16);
  303.     if (code>=16384 && !intra_vlc_format)
  304.       tab = &DCTtabnext[(code>>12)-4];
  305.     else if (code>=1024)
  306.     {
  307.       if (intra_vlc_format)
  308.         tab = &DCTtab0a[(code>>8)-4];
  309.       else
  310.         tab = &DCTtab0[(code>>8)-4];
  311.     }
  312.     else if (code>=512)
  313.     {
  314.       if (intra_vlc_format)
  315.         tab = &DCTtab1a[(code>>6)-8];
  316.       else
  317.         tab = &DCTtab1[(code>>6)-8];
  318.     }
  319.     else if (code>=256)
  320.       tab = &DCTtab2[(code>>4)-16];
  321.     else if (code>=128)
  322.       tab = &DCTtab3[(code>>3)-16];
  323.     else if (code>=64)
  324.       tab = &DCTtab4[(code>>2)-16];
  325.     else if (code>=32)
  326.       tab = &DCTtab5[(code>>1)-16];
  327.     else if (code>=16)
  328.       tab = &DCTtab6[code-16];
  329.     else
  330.     {
  331.       if (!Quiet_Flag)
  332.         printf("invalid Huffman code in Decode_MPEG2_Intra_Block()\n");
  333.       Fault_Flag = 1;
  334.       return;
  335.     }
  336.  
  337.     Flush_Buffer(tab->len);
  338.  
  339. #ifdef TRACE
  340.     if (Trace_Flag)
  341.     {
  342.       printf(" (");
  343.       Print_Bits(code,16,tab->len);
  344.     }
  345. #endif /* TRACE */
  346.  
  347.     if (tab->run==64) /* end_of_block */
  348.     {
  349. #ifdef TRACE
  350.       if (Trace_Flag)
  351.         printf("): EOB\n");
  352. #endif /* TRACE */
  353.       return;
  354.     }
  355.  
  356.     if (tab->run==65) /* escape */
  357.     {
  358. #ifdef TRACE
  359.       if (Trace_Flag)
  360.       {
  361.         putchar(' ');
  362.         Print_Bits(Show_Bits(6),6,6);
  363.       }
  364. #endif /* TRACE */
  365.  
  366.       i+= run = Get_Bits(6);
  367.  
  368. #ifdef TRACE
  369.       if (Trace_Flag)
  370.       {
  371.         putchar(' ');
  372.         Print_Bits(Show_Bits(12),12,12);
  373.       }
  374. #endif /* TRACE */
  375.  
  376.       val = Get_Bits(12);
  377.       if ((val&2047)==0)
  378.       {
  379.         if (!Quiet_Flag)
  380.           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
  381.         Fault_Flag = 1;
  382.         return;
  383.       }
  384.       if((sign = (val>=2048)))
  385.         val = 4096 - val;
  386.     }
  387.     else
  388.     {
  389.       i+= run = tab->run;
  390.       val = tab->level;
  391.       sign = Get_Bits(1);
  392.  
  393. #ifdef TRACE
  394.       if (Trace_Flag)
  395.         printf("%d",sign);
  396. #endif /* TRACE */
  397.     }
  398.  
  399.     if (i>=64)
  400.     {
  401.       if (!Quiet_Flag)
  402.         fprintf(stderr,"DCT coeff index (i) out of bounds (intra2)\n");
  403.       Fault_Flag = 1;
  404.       return;
  405.     }
  406.  
  407. #ifdef TRACE
  408.     if (Trace_Flag)
  409.       printf("): %d/%d",run,sign ? -val : val);
  410. #endif /* TRACE */
  411.  
  412.     j = scan[ld1->alternate_scan][i];
  413.     val = (val * ld1->quantizer_scale * qmat[j]) >> 4;
  414.     bp[j] = sign ? -val : val;
  415.     nc++;
  416.  
  417.     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
  418.       ld = &enhan;
  419.   }
  420. }
  421.  
  422.  
  423. /* decode one non-intra coded MPEG-2 block */
  424.  
  425. void Decode_MPEG2_Non_Intra_Block(comp)
  426. int comp;
  427. {
  428.   int val, i, j, sign, nc, run;
  429.   unsigned int code;
  430.   DCTtab *tab;
  431.   short *bp;
  432.   int *qmat;
  433.   struct layer_data *ld1;
  434.  
  435.   /* with data partitioning, data always goes to base layer */
  436.   ld1 = (ld->scalable_mode==SC_DP) ? &base : ld;
  437.   bp = ld1->block[comp];
  438.  
  439.   if (base.scalable_mode==SC_DP)
  440.     if (base.priority_breakpoint<64)
  441.       ld = &enhan;
  442.     else
  443.       ld = &base;
  444.  
  445.   qmat = (comp<4 || chroma_format==CHROMA420)
  446.          ? ld1->non_intra_quantizer_matrix
  447.          : ld1->chroma_non_intra_quantizer_matrix;
  448.  
  449.   nc = 0;
  450.  
  451. #ifdef TRACE
  452.   if (Trace_Flag)
  453.     printf("DCT(%d)n:",comp);
  454. #endif /* TRACE */
  455.  
  456.   /* decode AC coefficients */
  457.   for (i=0; ; i++)
  458.   {
  459.     code = Show_Bits(16);
  460.     if (code>=16384)
  461.     {
  462.       if (i==0)
  463.         tab = &DCTtabfirst[(code>>12)-4];
  464.       else
  465.         tab = &DCTtabnext[(code>>12)-4];
  466.     }
  467.     else if (code>=1024)
  468.       tab = &DCTtab0[(code>>8)-4];
  469.     else if (code>=512)
  470.       tab = &DCTtab1[(code>>6)-8];
  471.     else if (code>=256)
  472.       tab = &DCTtab2[(code>>4)-16];
  473.     else if (code>=128)
  474.       tab = &DCTtab3[(code>>3)-16];
  475.     else if (code>=64)
  476.       tab = &DCTtab4[(code>>2)-16];
  477.     else if (code>=32)
  478.       tab = &DCTtab5[(code>>1)-16];
  479.     else if (code>=16)
  480.       tab = &DCTtab6[code-16];
  481.     else
  482.     {
  483.       if (!Quiet_Flag)
  484.         printf("invalid Huffman code in Decode_MPEG2_Non_Intra_Block()\n");
  485.       Fault_Flag = 1;
  486.       return;
  487.     }
  488.  
  489.     Flush_Buffer(tab->len);
  490.  
  491. #ifdef TRACE
  492.     if (Trace_Flag)
  493.     {
  494.       printf(" (");
  495.       Print_Bits(code,16,tab->len);
  496.     }
  497. #endif /* TRACE */
  498.  
  499.     if (tab->run==64) /* end_of_block */
  500.     {
  501. #ifdef TRACE
  502.       if (Trace_Flag)
  503.         printf("): EOB\n");
  504. #endif /* TRACE */
  505.       return;
  506.     }
  507.  
  508.     if (tab->run==65) /* escape */
  509.     {
  510. #ifdef TRACE
  511.       if (Trace_Flag)
  512.       {
  513.         putchar(' ');
  514.         Print_Bits(Show_Bits(6),6,6);
  515.       }
  516. #endif /* TRACE */
  517.  
  518.       i+= run = Get_Bits(6);
  519.  
  520. #ifdef TRACE
  521.       if (Trace_Flag)
  522.       {
  523.         putchar(' ');
  524.         Print_Bits(Show_Bits(12),12,12);
  525.       }
  526. #endif /* TRACE */
  527.  
  528.       val = Get_Bits(12);
  529.       if ((val&2047)==0)
  530.       {
  531.         if (!Quiet_Flag)
  532.           printf("invalid escape in Decode_MPEG2_Intra_Block()\n");
  533.         Fault_Flag = 1;
  534.         return;
  535.       }
  536.       if((sign = (val>=2048)))
  537.         val = 4096 - val;
  538.     }
  539.     else
  540.     {
  541.       i+= run = tab->run;
  542.       val = tab->level;
  543.       sign = Get_Bits(1);
  544.  
  545. #ifdef TRACE
  546.       if (Trace_Flag)
  547.         printf("%d",sign);
  548. #endif /* TRACE */
  549.     }
  550.  
  551.     if (i>=64)
  552.     {
  553.       if (!Quiet_Flag)
  554.         fprintf(stderr,"DCT coeff index (i) out of bounds (inter2)\n");
  555.       Fault_Flag = 1;
  556.       return;
  557.     }
  558.  
  559. #ifdef TRACE
  560.     if (Trace_Flag)
  561.       printf("): %d/%d",run,sign?-val:val);
  562. #endif /* TRACE */
  563.  
  564.     j = scan[ld1->alternate_scan][i];
  565.     val = (((val<<1)+1) * ld1->quantizer_scale * qmat[j]) >> 5;
  566.     bp[j] = sign ? -val : val;
  567.     nc++;
  568.  
  569.     if (base.scalable_mode==SC_DP && nc==base.priority_breakpoint-63)
  570.       ld = &enhan;
  571.   }
  572. }
  573.